టైప్‌స్క్రిప్ట్ ఎన్యుమ్ ప్రత్యామ్నాయాలు: పటిష్టమైన కోడ్ కోసం కాన్స్ట్ అసర్షన్స్ మరియు యూనియన్ టైప్‌లను నావిగేట్ చేయడం

జావాస్క్రిప్ట్‌కు శక్తివంతమైన సూపర్‌సెట్ అయిన టైప్‌స్క్రిప్ట్, డైనమిక్ వెబ్ డెవలప్‌మెంట్ ప్రపంచానికి స్టాటిక్ టైపింగ్‌ను తీసుకువస్తుంది. దాని అనేక లక్షణాలలో, enum కీవర్డ్ చాలా కాలంగా పేరున్న స్థిరాంకాల సమితిని నిర్వచించడానికి ఒక ప్రామాణిక మార్గంగా ఉంది. ఎన్యుమ్‌లు సంబంధిత విలువల యొక్క స్థిరమైన సేకరణను సూచించడానికి స్పష్టమైన మార్గాన్ని అందిస్తాయి, రీడబిలిటీ మరియు టైప్ సేఫ్టీని మెరుగుపరుస్తాయి.

అయితే, టైప్‌స్క్రిప్ట్ ఎకోసిస్టమ్ పరిపక్వం చెందుతున్నప్పుడు మరియు ప్రాజెక్ట్‌లు సంక్లిష్టత మరియు స్థాయిలలో వృద్ధి చెందుతున్నప్పుడు, ప్రపంచవ్యాప్తంగా డెవలపర్‌లు ఎన్యుమ్‌ల యొక్క సాంప్రదాయ ప్రయోజనాన్ని ఎక్కువగా ప్రశ్నిస్తున్నారు. సాధారణ సందర్భాలకు సూటిగా ఉన్నప్పటికీ, ఎన్యుమ్‌లు కొన్ని ప్రవర్తనలు మరియు రన్‌టైమ్ లక్షణాలను పరిచయం చేస్తాయి, అవి కొన్నిసార్లు ఊహించని సమస్యలకు దారితీస్తాయి, బండిల్ పరిమాణాన్ని ప్రభావితం చేస్తాయి లేదా ట్రీ-షేకింగ్ ఆప్టిమైజేషన్‌లను సంక్లిష్టం చేస్తాయి. ఇది ప్రత్యామ్నాయాల విస్తృత అన్వేషణకు దారితీసింది.

ఈ సమగ్ర గైడ్ టైప్‌స్క్రిప్ట్ ఎన్యుమ్‌లకు రెండు ప్రముఖ మరియు అత్యంత ప్రభావవంతమైన ప్రత్యామ్నాయాలలోకి లోతుగా పరిశోధిస్తుంది: స్ట్రింగ్/న్యూమరిక్ లిటరల్స్‌తో యూనియన్ టైప్‌లు మరియు కాన్స్ట్ అసర్షన్స్ (as const). మేము వాటి మెకానిజమ్స్, ఆచరణాత్మక అనువర్తనాలు, ప్రయోజనాలు మరియు నష్టాలను అన్వేషిస్తాము, మీ ప్రాజెక్ట్‌ల పరిమాణం లేదా వాటిపై పనిచేసే గ్లోబల్ టీమ్‌తో సంబంధం లేకుండా మీ ప్రాజెక్ట్‌ల కోసం సమాచార డిజైన్ నిర్ణయాలు తీసుకోవడానికి మీకు జ్ఞానాన్ని అందిస్తాము. మరింత పటిష్టమైన, నిర్వహించదగిన మరియు సమర్థవంతమైన టైప్‌స్క్రిప్ట్ కోడ్‌ను వ్రాయడానికి మీకు అధికారం కల్పించడమే మా లక్ష్యం.

టైప్‌స్క్రిప్ట్ ఎన్యుమ్: ఒక సంక్షిప్త పునశ్చరణ

ప్రత్యామ్నాయాలలోకి ప్రవేశించే ముందు, సాంప్రదాయ టైప్‌స్క్రిప్ట్ enumను క్లుప్తంగా మళ్లీ చూద్దాం. ఎన్యుమ్‌లు డెవలపర్‌లకు పేరున్న స్థిరాంకాల సమితిని నిర్వచించడానికి అనుమతిస్తాయి, కోడ్‌ను మరింత రీడబుల్‌గా మారుస్తాయి మరియు "మ్యాజిక్ స్ట్రింగ్స్" లేదా "మ్యాజిక్ నంబర్‌లు" అప్లికేషన్ అంతటా చెల్లాచెదురుగా ఉండకుండా నిరోధిస్తాయి. అవి రెండు ప్రాథమిక రూపాల్లో వస్తాయి: న్యూమరిక్ మరియు స్ట్రింగ్ ఎన్యుమ్‌లు.

న్యూమరిక్ ఎన్యుమ్‌లు

డిఫాల్ట్‌గా, టైప్‌స్క్రిప్ట్ ఎన్యుమ్‌లు న్యూమరిక్. మొదటి సభ్యుడు 0తో ప్రారంభించబడతాడు మరియు ప్రతి తదుపరి సభ్యుడు ఆటో-ఇంక్రిమెంట్ చేయబడతాడు.

            enum Direction {
  Up,
  Down,
  Left,
  Right,
}

let currentDirection: Direction = Direction.Up;
console.log(currentDirection); // Outputs: 0
console.log(Direction.Left);    // Outputs: 2

            

              
                Copy
              
            
          

మీరు న్యూమరిక్ ఎన్యుమ్ సభ్యులను మాన్యువల్‌గా కూడా ప్రారంభించవచ్చు:

            enum StatusCode {
  Success = 200,
  NotFound = 404,
  ServerError = 500,
}

let status: StatusCode = StatusCode.NotFound;
console.log(status); // Outputs: 404

            

              
                Copy
              
            
          

న్యూమరిక్ ఎన్యుమ్‌ల యొక్క ఒక ప్రత్యేక లక్షణం రివర్స్ మ్యాపింగ్. రన్‌టైమ్‌లో, ఒక న్యూమరిక్ ఎన్యుమ్ జావాస్క్రిప్ట్ ఆబ్జెక్ట్‌గా కంపైల్ చేయబడుతుంది, అది పేర్లను విలువలకు మరియు విలువలను పేర్లకు మ్యాప్ చేస్తుంది.

            enum UserRole {
  Admin = 1,
  Editor,
  Viewer,
}

console.log(UserRole[1]); // Outputs: "Admin"
console.log(UserRole.Editor); // Outputs: 2
console.log(UserRole[2]); // Outputs: "Editor"

/*
Compiles to JavaScript:
var UserRole;
(function (UserRole) {
    UserRole[UserRole["Admin"] = 1] = "Admin";
    UserRole[UserRole["Editor"] = 2] = "Editor";
    UserRole[UserRole["Viewer"] = 3] = "Viewer";
})(UserRole || (UserRole = {}));
*/

            

              
                Copy
              
            
          

స్ట్రింగ్ ఎన్యుమ్‌లు

స్ట్రింగ్ ఎన్యుమ్‌లు రన్‌టైమ్‌లో వాటి రీడబిలిటీ కోసం తరచుగా ఇష్టపడతారు, ఎందుకంటే అవి ఆటో-ఇంక్రిమెంటింగ్ సంఖ్యలపై ఆధారపడవు. ప్రతి సభ్యుడు స్ట్రింగ్ లిటరల్‌తో ప్రారంభించబడాలి.

            enum UserPermission {
  Read = "READ_PERMISSION",
  Write = "WRITE_PERMISSION",
  Delete = "DELETE_PERMISSION",
}

let permission: UserPermission = UserPermission.Write;
console.log(permission); // Outputs: "WRITE_PERMISSION"

            

              
                Copy
              
            
          

స్ట్రింగ్ ఎన్యుమ్‌లకు రివర్స్ మ్యాపింగ్ ఉండదు, ఇది సాధారణంగా ఊహించని రన్‌టైమ్ ప్రవర్తనను నివారించడానికి మరియు ఉత్పత్తి చేయబడిన జావాస్క్రిప్ట్ అవుట్‌పుట్‌ను తగ్గించడానికి మంచి విషయం.

ఎన్యుమ్‌ల యొక్క ముఖ్యమైన పరిగణనలు మరియు సంభావ్య నష్టాలు

ఎన్యుమ్‌లు సౌలభ్యాన్ని అందిస్తున్నప్పటికీ, అవి జాగ్రత్తగా పరిగణించదగిన కొన్ని లక్షణాలతో వస్తాయి:

• రన్‌టైమ్ ఆబ్జెక్ట్‌లు: న్యూమరిక్ మరియు స్ట్రింగ్ ఎన్యుమ్‌లు రెండూ రన్‌టైమ్‌లో జావాస్క్రిప్ట్ ఆబ్జెక్ట్‌లను ఉత్పత్తి చేస్తాయి. అంటే మీరు వాటిని టైప్-చెకింగ్ కోసం మాత్రమే ఉపయోగించినప్పటికీ, అవి మీ అప్లికేషన్ యొక్క బండిల్ పరిమాణానికి దోహదపడతాయి. చిన్న ప్రాజెక్ట్‌ల కోసం, ఇది తక్కువగా ఉండవచ్చు, కానీ అనేక ఎన్యుమ్‌లతో కూడిన పెద్ద-స్థాయి అప్లికేషన్‌లలో, అది పెరిగిపోవచ్చు.
• ట్రీ-షేకింగ్ లేకపోవడం: ఎన్యుమ్‌లు రన్‌టైమ్ ఆబ్జెక్ట్‌లు కాబట్టి, వెబ్‌ప్యాక్ లేదా రోలప్ వంటి ఆధునిక బండలర్‌ల ద్వారా అవి తరచుగా సమర్థవంతంగా ట్రీ-షేక్ చేయబడవు. మీరు ఒక ఎన్యుమ్‌ను నిర్వచించి, దాని సభ్యులలో ఒకటి లేదా రెండు మాత్రమే ఉపయోగించినా, మొత్తం ఎన్యుమ్ ఆబ్జెక్ట్ మీ చివరి బండిల్‌లో చేర్చబడవచ్చు. ఇది అవసరమైన దానికంటే పెద్ద ఫైల్ పరిమాణాలకు దారితీయవచ్చు.
• రివర్స్ మ్యాపింగ్ (న్యూమరిక్ ఎన్యుమ్‌లు): న్యూమరిక్ ఎన్యుమ్‌ల యొక్క రివర్స్ మ్యాపింగ్ ఫీచర్, కొన్నిసార్లు ఉపయోగకరంగా ఉన్నప్పటికీ, గందరగోళానికి మరియు ఊహించని ప్రవర్తనకు కూడా మూలంగా ఉంటుంది. ఇది జావాస్క్రిప్ట్ అవుట్‌పుట్‌కు అదనపు కోడ్‌ను జోడిస్తుంది మరియు కావలసిన కార్యాచరణ ఎల్లప్పుడూ కాకపోవచ్చు. ఉదాహరణకు, న్యూమరిక్ ఎన్యుమ్‌లను సీరియలైజ్ చేయడం కొన్నిసార్లు సంఖ్య మాత్రమే నిల్వ చేయబడటానికి దారితీయవచ్చు, ఇది స్ట్రింగ్ వలె వివరణాత్మకంగా ఉండకపోవచ్చు.
• ట్రాన్స్‌పిలేషన్ ఓవర్‌హెడ్: ఎన్యుమ్‌లను జావాస్క్రిప్ట్ ఆబ్జెక్ట్‌లుగా కంపైల్ చేయడం అనేది స్థిరమైన వేరియబుల్స్‌ను నిర్వచించడంతో పోలిస్తే బిల్డ్ ప్రాసెస్‌కు కొద్దిపాటి ఓవర్‌హెడ్‌ను జోడిస్తుంది.
• పరిమిత ఇటరేషన్: ఎన్యుమ్ విలువలపై నేరుగా ఇటరేషన్ చేయడం సులువు కాదు, ముఖ్యంగా న్యూమరిక్ ఎన్యుమ్‌లతో రివర్స్ మ్యాపింగ్ కారణంగా. మీరు తరచుగా కావలసిన విలువలను పొందడానికి సహాయక ఫంక్షన్‌లు లేదా నిర్దిష్ట లూప్‌లు అవసరం.

ఈ పాయింట్లు అనేక ప్రపంచ అభివృద్ధి బృందాలు, ముఖ్యంగా పనితీరు మరియు బండిల్ పరిమాణంపై దృష్టి సారించేవి, రన్‌టైమ్ ఫుట్‌ప్రింట్ లేదా ఇతర సంక్లిష్టతలు లేకుండా ఇలాంటి టైప్ సేఫ్టీని అందించే ప్రత్యామ్నాయాల వైపు ఎందుకు చూస్తున్నాయో హైలైట్ చేస్తాయి.

ప్రత్యామ్నాయం 1: లిటరల్స్‌తో యూనియన్ టైప్‌లు

టైప్‌స్క్రిప్ట్‌లో ఎన్యుమ్‌లకు అత్యంత సూటిగా మరియు శక్తివంతమైన ప్రత్యామ్నాయాలలో ఒకటి స్ట్రింగ్ లేదా న్యూమరిక్ లిటరల్స్‌తో యూనియన్ టైప్‌లు ఉపయోగించడం. ఈ విధానం టైప్‌స్క్రిప్ట్ యొక్క పటిష్టమైన టైప్ సిస్టమ్‌ను ఉపయోగించి కంపైల్-టైమ్‌లో నిర్దిష్ట, అనుమతించబడిన విలువల సమితిని నిర్వచిస్తుంది, రన్‌టైమ్‌లో ఎటువంటి కొత్త నిర్మానాలను పరిచయం చేయకుండా.

యూనియన్ టైప్‌లు అంటే ఏమిటి?

ఒక యూనియన్ టైప్ అనేక రకాలైన విలువలలో ఒకటిగా ఉండే విలువను వివరిస్తుంది. ఉదాహరణకు, string | number అంటే ఒక వేరియబుల్ స్ట్రింగ్ లేదా నంబర్‌ను కలిగి ఉండగలదు. లిటరల్ టైప్‌లతో (ఉదా., "success", 404) కలిపి, మీరు ముందుగా నిర్వచించిన విలువల నిర్దిష్ట సమితిని మాత్రమే కలిగి ఉండే టైప్‌ను నిర్వచించవచ్చు.

ఆచరణాత్మక ఉదాహరణ: యూనియన్ టైప్‌లతో స్టేటస్‌లను నిర్వచించడం

ఒక సాధారణ దృశ్యాన్ని పరిగణించండి: డేటా ప్రాసెసింగ్ ఉద్యోగం లేదా వినియోగదారు ఖాతా కోసం సాధ్యమయ్యే స్టేటస్‌ల సమితిని నిర్వచించడం. యూనియన్ టైప్‌లతో, ఇది శుభ్రంగా మరియు సంక్షిప్తంగా కనిపిస్తుంది:

            type JobStatus = "PENDING" | "IN_PROGRESS" | "COMPLETED" | "FAILED";

function processJob(status: JobStatus): void {
  if (status === "COMPLETED") {
    console.log("Job finished successfully.");
  } else if (status === "FAILED") {
    console.log("Job encountered an error.");
  } else {
    console.log(`Job is currently ${status}.`);
  }
}

let currentJobStatus: JobStatus = "IN_PROGRESS";
processJob(currentJobStatus);

// This would result in a compile-time error:
// let invalidStatus: JobStatus = "CANCELLED"; // Error: Type '"CANCELLED"' is not assignable to type 'JobStatus'.

            

              
                Copy
              
            
          

సంఖ్యాత్మక విలువల కోసం, నమూనా ఒకే విధంగా ఉంటుంది:

            type HttpCode = 200 | 400 | 404 | 500;

function handleResponse(code: HttpCode): void {
  if (code === 200) {
    console.log("Operation successful.");
  } else if (code === 404) {
    console.log("Resource not found.");
  }
}

let responseStatus: HttpCode = 200;
handleResponse(responseStatus);

            

              
                Copy
              
            
          

ఇక్కడ మనం type అలియాస్‌ను ఎలా నిర్వచిస్తున్నామో గమనించండి. ఇది పూర్తిగా కంపైల్-టైమ్ నిర్మాణం. జావాస్క్రిప్ట్‌కు కంపైల్ చేసినప్పుడు, JobStatus కేవలం అదృశ్యమవుతుంది మరియు లిటరల్ స్ట్రింగ్‌లు/సంఖ్యలు నేరుగా ఉపయోగించబడతాయి.

లిటరల్స్‌తో యూనియన్ టైప్‌ల ప్రయోజనాలు

ఈ విధానం అనేక బలమైన ప్రయోజనాలను అందిస్తుంది:

• పూర్తిగా కంపైల్-టైమ్: యూనియన్ టైప్‌లు కంపైలేషన్ సమయంలో పూర్తిగా తొలగించబడతాయి. అవి రన్‌టైమ్‌లో ఎటువంటి జావాస్క్రిప్ట్ కోడ్‌ను ఉత్పత్తి చేయవు, దీనివల్ల బండిల్ పరిమాణాలు చిన్నవిగా ఉంటాయి మరియు అప్లికేషన్ స్టార్టప్ సమయాలు వేగంగా ఉంటాయి. పనితీరు-క్లిష్టమైన అప్లికేషన్‌లకు మరియు ప్రతి కిలోబైట్ ముఖ్యమైన ప్రపంచవ్యాప్తంగా విస్తరించబడిన వాటికి ఇది గణనీయమైన ప్రయోజనం.
• అద్భుతమైన టైప్ సేఫ్టీ: టైప్‌స్క్రిప్ట్ నిర్వచించిన లిటరల్ టైప్‌లకు వ్యతిరేకంగా అసైన్‌మెంట్‌లను ఖచ్చితంగా తనిఖీ చేస్తుంది, చెల్లుబాటు అయ్యే విలువలు మాత్రమే ఉపయోగించబడుతున్నాయని బలమైన హామీలను అందిస్తుంది. ఇది టైపోలు లేదా తప్పు విలువల వల్ల సంభవించే సాధారణ బగ్‌లను నిరోధిస్తుంది.
• ఆప్టిమల్ ట్రీ-షేకింగ్: రన్‌టైమ్ ఆబ్జెక్ట్ లేనందున, యూనియన్ టైప్‌లు అంతర్గతంగా ట్రీ-షేకింగ్‌కు మద్దతు ఇస్తాయి. మీ బండలర్ మీరు ఉపయోగించే అసలు స్ట్రింగ్ లేదా న్యూమరిక్ లిటరల్స్‌ను మాత్రమే చేర్చుతుంది, మొత్తం ఆబ్జెక్ట్‌ను కాదు.
• రీడబిలిటీ: సాధారణ, విభిన్న విలువల యొక్క స్థిరమైన సమితి కోసం, టైప్ నిర్వచనం తరచుగా చాలా స్పష్టంగా మరియు సులభంగా అర్థమవుతుంది.
• సరళత: కొత్త భాషా నిర్మాణాలు లేదా సంక్లిష్ట కంపైలేషన్ ఆర్టిఫ్యాక్ట్‌లు పరిచయం చేయబడవు. ఇది కేవలం ప్రాథమిక టైప్‌స్క్రిప్ట్ టైప్ లక్షణాలను ఉపయోగించుకుంటుంది.
• ప్రత్యక్ష విలువ యాక్సెస్: మీరు స్ట్రింగ్ లేదా నంబర్ విలువల‌తో నేరుగా పని చేస్తారు, ఇది సీరియలైజేషన్ మరియు డిసీరియలైజేషన్‌ను సులభతరం చేస్తుంది, ముఖ్యంగా నిర్దిష్ట స్ట్రింగ్ ఐడెంటిఫైయర్‌లను ఆశించే APIలు లేదా డేటాబేస్‌లతో సంభాషించినప్పుడు.

లిటరల్స్‌తో యూనియన్ టైప్‌ల అప్రయోజనాలు

శక్తివంతమైన అయినప్పటికీ, యూనియన్ టైప్‌లకు కొన్ని పరిమితులు కూడా ఉన్నాయి:

• అనుబంధిత డేటా కోసం పునరావృతం: మీరు ప్రతి "enum" సభ్యునితో అదనపు డేటా లేదా మెటాడేటాను (ఉదా., డిస్‌ప్లే లేబుల్, ఒక ఐకాన్, ఒక రంగు) అనుబంధించవలసి వస్తే, మీరు దీన్ని యూనియన్ టైప్ నిర్వచనం లోపల నేరుగా చేయలేరు. మీకు సాధారణంగా ఒక ప్రత్యేక మ్యాపింగ్ ఆబ్జెక్ట్ అవసరం.
• అన్ని విలువల యొక్క ప్రత్యక్ష ఇటరేషన్ లేదు: రన్‌టైమ్‌లో యూనియన్ టైప్ నుండి సాధ్యమయ్యే అన్ని విలువల శ్రేణిని పొందడానికి అంతర్నిర్మిత మార్గం లేదు. ఉదాహరణకు, మీరు ["PENDING", "IN_PROGRESS", "COMPLETED", "FAILED"]ను నేరుగా JobStatus నుండి సులభంగా పొందలేరు. UIలో (ఉదా., డ్రాప్‌డౌన్ మెను) వాటిని ప్రదర్శించవలసి వస్తే విలువల యొక్క ప్రత్యేక శ్రేణిని నిర్వహించడం తరచుగా అవసరం.
• తక్కువ కేంద్రీకృతం: విలువల సమితి ఒక రకంగా మరియు రన్‌టైమ్ విలువల శ్రేణిగా అవసరమైతే, మీరు జాబితాను రెండుసార్లు (ఒకసారి టైప్‌గా, ఒకసారి రన్‌టైమ్ శ్రేణిగా) నిర్వచించడాన్ని చూడవచ్చు, ఇది డీసింక్రనైజేషన్ సంభావ్యతను పరిచయం చేయగలదు.

ఈ లోపాలు ఉన్నప్పటికీ, అనేక దృశ్యాల కోసం, యూనియన్ టైప్‌లు ఆధునిక జావాస్క్రిప్ట్ అభివృద్ధి పద్ధతులకు చక్కగా సరిపోయే శుభ్రమైన, పనితీరు గల మరియు టైప్-సేఫ్ పరిష్కారాన్ని అందిస్తాయి.

ప్రత్యామ్నాయం 2: కాన్స్ట్ అసర్షన్స్ (as const)

టైప్‌స్క్రిప్ట్ 3.4లో ప్రవేశపెట్టబడిన as const అసర్షన్, ఎన్యుమ్‌లకు అద్భుతమైన ప్రత్యామ్నాయాన్ని అందించే మరో నమ్మశక్యం కాని శక్తివంతమైన సాధనం, ముఖ్యంగా మీకు రన్‌టైమ్ ఆబ్జెక్ట్ మరియు పటిష్టమైన టైప్ ఇన్‌ఫరెన్స్ అవసరమైనప్పుడు. ఇది లిటరల్ వ్యక్తీకరణల కోసం సాధ్యమయ్యే అత్యంత ఇరుకైన టైప్‌ను ఊహించడానికి టైప్‌స్క్రిప్ట్‌ను అనుమతిస్తుంది.

కాన్స్ట్ అసర్షన్స్ అంటే ఏమిటి?

మీరు ఒక వేరియబుల్, ఒక శ్రేణి లేదా ఒక ఆబ్జెక్ట్ లిటరల్‌కు as constను వర్తింపజేసినప్పుడు, టైప్‌స్క్రిప్ట్ ఆ లిటరల్ లోపల ఉన్న అన్ని ప్రాపర్టీలను readonlyగా పరిగణిస్తుంది మరియు విస్తృత టైప్‌లకు (ఉదా., string బదులుగా "foo", number బదులుగా 123) బదులుగా వాటి లిటరల్ టైప్‌లను ఊహిస్తుంది. ఇది రన్‌టైమ్ డేటా నిర్మాణాల నుండి అత్యంత నిర్దిష్ట యూనియన్ టైప్‌లను పొందేలా చేస్తుంది.

ఆచరణాత్మక ఉదాహరణ: as constతో "సూడో-ఎన్యుమ్" ఆబ్జెక్ట్‌ను సృష్టించడం

మన ఉద్యోగ స్థితి ఉదాహరణను మళ్లీ చూద్దాం. as constతో, మనం మన స్టేటస్‌ల కోసం ఒకే సత్యాన్ని నిర్వచించవచ్చు, ఇది రన్‌టైమ్ ఆబ్జెక్ట్‌గా మరియు టైప్ నిర్వచనాల కోసం ఒక ఆధారంగా పనిచేస్తుంది.

            const JobStatuses = {
  PENDING: "PENDING",
  IN_PROGRESS: "IN_PROGRESS",
  COMPLETED: "COMPLETED",
  FAILED: "FAILED",
} as const;

// JobStatuses.PENDING is now inferred as type "PENDING" (not just string)
// JobStatuses is inferred as type {
//   readonly PENDING: "PENDING";
//   readonly IN_PROGRESS: "IN_PROGRESS";
//   readonly COMPLETED: "COMPLETED";
//   readonly FAILED: "FAILED";
// }

            

              
                Copy
              
            
          

ఈ సమయంలో, JobStatuses రన్‌టైమ్‌లో జావాస్క్రిప్ట్ ఆబ్జెక్ట్, సాధారణ ఎన్యుమ్ లాగానే. అయితే, దాని టైప్ ఇన్‌ఫరెన్స్ చాలా ఖచ్చితమైనది.

యూనియన్ టైప్‌ల కోసం typeof మరియు keyofతో కలపడం

as constను టైప్‌స్క్రిప్ట్ యొక్క typeof మరియు keyof ఆపరేటర్‌లతో కలిపినప్పుడు అసలు శక్తి బయటపడుతుంది, తద్వారా ఆబ్జెక్ట్ యొక్క విలువలు లేదా కీల నుండి యూనియన్ టైప్‌ను పొందవచ్చు.

            const JobStatuses = {
  PENDING: "PENDING",
  IN_PROGRESS: "IN_PROGRESS",
  COMPLETED: "COMPLETED",
  FAILED: "FAILED",
} as const;

// Type representing the keys (e.g., "PENDING" | "IN_PROGRESS" | ...)
type JobStatusKeys = keyof typeof JobStatuses;

// Type representing the values (e.g., "PENDING" | "IN_PROGRESS" | ...)
type JobStatusValues = typeof JobStatuses[keyof typeof JobStatuses];

function processJobWithConstAssertion(status: JobStatusValues): void {
  if (status === JobStatuses.COMPLETED) {
    console.log("Job finished successfully.");
  } else if (status === JobStatuses.FAILED) {
    console.log("Job encountered an error.");
  } else {
    console.log(`Job is currently ${status}.`);
  }
}

let currentJobStatusFromObject: JobStatusValues = JobStatuses.IN_PROGRESS;
processJobWithConstAssertion(currentJobStatusFromObject);

// This would result in a compile-time error:
// let invalidStatusFromObject: JobStatusValues = "CANCELLED"; // Error!

            

              
                Copy
              
            
          

ఈ నమూనా రెండు ప్రపంచాలలో ఉత్తమమైన వాటిని అందిస్తుంది: ఇటరేషన్ లేదా ప్రత్యక్ష ప్రాపర్టీ యాక్సెస్ కోసం రన్‌టైమ్ ఆబ్జెక్ట్, మరియు ఖచ్చితమైన టైప్ చెకింగ్ కోసం కంపైల్-టైమ్ యూనియన్ టైప్.

ఉత్పన్న యూనియన్ టైప్‌లతో కాన్స్ట్ అసర్షన్స్ ప్రయోజనాలు

• సత్యానికి ఒకే మూలం: మీరు మీ స్థిరాంకాలను ఒక సాధారణ జావాస్క్రిప్ట్ ఆబ్జెక్ట్‌లో ఒకసారి నిర్వచిస్తారు మరియు దాని నుండి రన్‌టైమ్ యాక్సెస్ మరియు కంపైల్-టైమ్ టైప్‌లను పొందుతారు. ఇది నకిలీని గణనీయంగా తగ్గిస్తుంది మరియు విభిన్న అభివృద్ధి బృందాలలో నిర్వహణను మెరుగుపరుస్తుంది.
• టైప్ సేఫ్టీ: స్వచ్ఛమైన యూనియన్ టైప్‌ల మాదిరిగానే, మీరు అద్భుతమైన టైప్ సేఫ్టీని పొందుతారు, ముందుగా నిర్వచించిన విలువలు మాత్రమే ఉపయోగించబడుతున్నాయని నిర్ధారిస్తుంది.
• రన్‌టైమ్‌లో ఇటరేషన్ సామర్థ్యం: JobStatuses ఒక సాధారణ జావాస్క్రిప్ట్ ఆబ్జెక్ట్ కాబట్టి, మీరు Object.keys(), Object.values() లేదా Object.entries() వంటి ప్రామాణిక జావాస్క్రిప్ట్ పద్ధతులను ఉపయోగించి దాని కీలు లేదా విలువలపై సులభంగా ఇటరేట్ చేయవచ్చు. డైనమిక్ UIల (ఉదా., డ్రాప్‌డౌన్‌లను నింపడం) లేదా లాగింగ్ కోసం ఇది అమూల్యమైనది.
• అనుబంధిత డేటా: ఈ నమూనా సహజంగా ప్రతి "enum" సభ్యునితో అదనపు డేటాను అనుబంధించడానికి మద్దతు ఇస్తుంది.
• మెరుగైన ట్రీ-షేకింగ్ సంభావ్యత (ఎన్యుమ్‌లతో పోలిస్తే): as const రన్‌టైమ్ ఆబ్జెక్ట్‌ను సృష్టించినప్పటికీ, ఇది ఒక ప్రామాణిక జావాస్క్రిప్ట్ ఆబ్జెక్ట్. టైప్‌స్క్రిప్ట్ యొక్క ఎన్యుమ్ కంపైలేషన్ అవుట్‌పుట్‌తో పోలిస్తే, ఆధునిక బండలర్‌లు సాధారణంగా ఉపయోగించని ప్రాపర్టీలను లేదా రిఫరెన్స్ చేయకపోతే మొత్తం ఆబ్జెక్ట్‌లను ట్రీ-షేకింగ్ చేయడంలో మరింత ప్రభావవంతంగా ఉంటాయి. అయితే, ఆబ్జెక్ట్ పెద్దదిగా ఉండి, కొన్ని ప్రాపర్టీలు మాత్రమే ఉపయోగించబడితే, గ్రాన్యులర్ ట్రీ-షేకింగ్‌ను నిరోధించే విధంగా దిగుమతి చేసుకుంటే మొత్తం ఆబ్జెక్ట్ ఇప్పటికీ చేర్చబడవచ్చు.
• ఫ్లెక్సిబిలిటీ: మీరు స్ట్రింగ్‌లు లేదా సంఖ్యలు మాత్రమే కాకుండా, అవసరమైతే మరింత సంక్లిష్టమైన ఆబ్జెక్ట్‌లను కూడా నిర్వచించవచ్చు, ఇది అత్యంత సౌకర్యవంతమైన నమూనాని చేస్తుంది.

            const FileOperations = {
  UPLOAD: {
    label: "Upload File",
    icon: "upload-icon.svg",
    permission: "can_upload"
  },
  DOWNLOAD: {
    label: "Download File",
    icon: "download-icon.svg",
    permission: "can_download"
  },
  DELETE: {
    label: "Delete File",
    icon: "delete-icon.svg",
    permission: "can_delete"
  },
} as const;

type FileOperationType = keyof typeof FileOperations; // "UPLOAD" | "DOWNLOAD" | "DELETE"
type FileOperationDetail = typeof FileOperations[keyof typeof FileOperations]; // { label: string; icon: string; permission: string; }

function performOperation(opType: FileOperationType) {
  const details = FileOperations[opType];
  console.log(`Performing: ${details.label} (Permission: ${details.permission})`);
}

performOperation("UPLOAD");

            

              
                Copy
              
            
          

కాన్స్ట్ అసర్షన్స్ అప్రయోజనాలు

• రన్‌టైమ్ ఆబ్జెక్ట్ ఉనికి: స్వచ్ఛమైన యూనియన్ టైప్‌ల వలె కాకుండా, ఈ విధానం ఇప్పటికీ రన్‌టైమ్‌లో జావాస్క్రిప్ట్ ఆబ్జెక్ట్‌ను సృష్టిస్తుంది. ఇది ఒక ప్రామాణిక ఆబ్జెక్ట్ మరియు ఎన్యుమ్‌ల కంటే ట్రీ-షేకింగ్ కోసం తరచుగా మెరుగ్గా ఉన్నప్పటికీ, ఇది పూర్తిగా తొలగించబడదు.
• కొంచెం ఎక్కువ వర్బోస్ టైప్ నిర్వచనం: యూనియన్ టైప్‌ను (keyof typeof ... లేదా typeof ...[keyof typeof ...]) పొందడానికి యూనియన్ టైప్ కోసం కేవలం లిటరల్స్‌ను జాబితా చేయడం కంటే కొంచెం ఎక్కువ సింటాక్స్ అవసరం.
• దుర్వినియోగానికి సంభావ్యత: జాగ్రత్తగా ఉపయోగించకపోతే, ఒక చాలా పెద్ద as const ఆబ్జెక్ట్ దాని కంటెంట్‌లు మాడ్యూల్ సరిహద్దులలో సమర్థవంతంగా ట్రీ-షేక్ చేయకపోతే బండిల్ పరిమాణానికి గణనీయంగా దోహదపడవచ్చు.

మీకు పటిష్టమైన కంపైల్-టైమ్ టైప్ చెకింగ్ మరియు ఇటరేట్ చేయగల లేదా అనుబంధిత డేటాను అందించగల రన్‌టైమ్ విలువల సేకరణ రెండూ అవసరమైన దృశ్యాల కోసం, as const తరచుగా ప్రపంచవ్యాప్తంగా టైప్‌స్క్రిప్ట్ డెవలపర్‌లలో ఇష్టపడే ఎంపిక.

ప్రత్యామ్నాయాలను పోల్చడం: ఏది ఎప్పుడు ఉపయోగించాలి?

యూనియన్ టైప్‌లు మరియు కాన్స్ట్ అసర్షన్‌ల మధ్య ఎంచుకోవడం అనేది రన్‌టైమ్ ఉనికి, ఇటరేషన్ సామర్థ్యం మరియు మీ స్థిరాంకాలతో అదనపు డేటాను అనుబంధించాల్సిన అవసరం వంటి మీ నిర్దిష్ట అవసరాలపై ఎక్కువగా ఆధారపడి ఉంటుంది. నిర్ణయం తీసుకునే అంశాలను విశ్లేషిద్దాం.

సరళత వర్సెస్ పటిష్టత

• యూనియన్ టైప్‌లు: కంపైల్-టైమ్‌లో విభిన్న స్ట్రింగ్ లేదా న్యూమరిక్ విలువల యొక్క టైప్-సేఫ్ సమితి మాత్రమే మీకు అవసరమైనప్పుడు అత్యంత సరళతను అందిస్తాయి. అవి అత్యంత తేలికపాటి ఎంపిక.
• కాన్స్ట్ అసర్షన్స్: మీకు కంపైల్-టైమ్ టైప్ సేఫ్టీ మరియు రన్‌టైమ్ ఆబ్జెక్ట్ రెండూ అవసరమైనప్పుడు మరింత పటిష్టమైన నమూనాని అందిస్తాయి, దానిని క్వెరీ చేయవచ్చు, ఇటరేట్ చేయవచ్చు లేదా అదనపు మెటాడేటాతో విస్తరించవచ్చు. ప్రారంభ సెటప్ కొంచెం ఎక్కువ వర్బోస్‌గా ఉంటుంది, కానీ ఇది లక్షణాలలో ప్రయోజనకరంగా ఉంటుంది.

రన్‌టైమ్ వర్సెస్ కంపైల్-టైమ్ ఉనికి

• యూనియన్ టైప్‌లు: పూర్తిగా కంపైల్-టైమ్ నిర్మాణాలు. అవి ఖచ్చితంగా ఎటువంటి జావాస్క్రిప్ట్ కోడ్‌ను ఉత్పత్తి చేయవు. బండిల్ పరిమాణాన్ని తగ్గించడం అత్యంత ముఖ్యమైన అప్లికేషన్‌లకు మరియు రన్‌టైమ్‌లో ఆబ్జెక్ట్‌గా వాటిని యాక్సెస్ చేయాల్సిన అవసరం లేకుండా విలువలు సరిపోతాయి.
• కాన్స్ట్ అసర్షన్స్: రన్‌టైమ్‌లో సాధారణ జావాస్క్రిప్ట్ ఆబ్జెక్ట్‌ను ఉత్పత్తి చేస్తాయి. ఈ ఆబ్జెక్ట్ మీ జావాస్క్రిప్ట్ కోడ్‌లో అందుబాటులో ఉంటుంది మరియు ఉపయోగించదగినది. ఇది బండిల్ పరిమాణాన్ని పెంచినప్పటికీ, ఇది టైప్‌స్క్రిప్ట్ ఎన్యుమ్‌ల కంటే సాధారణంగా మరింత సమర్థవంతమైనది మరియు ట్రీ-షేకింగ్ కోసం మంచి అభ్యర్థులు.

ఇటరేషన్ సామర్థ్య అవసరాలు

• యూనియన్ టైప్‌లు: రన్‌టైమ్‌లో సాధ్యమయ్యే అన్ని విలువలపై ఇటరేట్ చేయడానికి ప్రత్యక్ష మార్గాన్ని అందించవు. మీరు డ్రాప్‌డౌన్ మెనును పూరించడానికి లేదా అన్ని ఎంపికలను ప్రదర్శించడానికి అవసరమైతే, మీరు ఈ విలువల యొక్క ప్రత్యేక శ్రేణిని నిర్వచించాలి, ఇది నకిలీకి దారితీయవచ్చు.
• కాన్స్ట్ అసర్షన్స్: ఇక్కడ అత్యుత్తమంగా ఉంటాయి. మీరు ఒక ప్రామాణిక జావాస్క్రిప్ట్ ఆబ్జెక్ట్‌తో పని చేస్తున్నందున, మీరు Object.keys(), Object.values() లేదా Object.entries()లను ఉపయోగించి కీలు, విలువలు లేదా కీ-విలువ జతల శ్రేణిని సులభంగా పొందవచ్చు. డైనమిక్ UIల లేదా రన్‌టైమ్ ఎన్యూమరేషన్ అవసరమయ్యే ఏదైనా సందర్భం కోసం అవి సరైనవి.

            const PaymentMethods = {
  CREDIT_CARD: "Credit Card",
  PAYPAL: "PayPal",
  BANK_TRANSFER: "Bank Transfer",
} as const;

type PaymentMethodType = keyof typeof PaymentMethods;

// Get all keys (e.g., for internal logic)
const methodKeys = Object.keys(PaymentMethods) as PaymentMethodType[];
console.log(methodKeys); // ["CREDIT_CARD", "PAYPAL", "BANK_TRANSFER"]

// Get all values (e.g., for display in a dropdown)
const methodLabels = Object.values(PaymentMethods);
console.log(methodLabels); // ["Credit Card", "PayPal", "Bank Transfer"]

// Get key-value pairs (e.g., for mapping)
const methodEntries = Object.entries(PaymentMethods);
console.log(methodEntries); // [["CREDIT_CARD", "Credit Card"], ...]

            

              
                Copy
              
            
          

ట్రీ-షేకింగ్ చిక్కులు

• యూనియన్ టైప్‌లు: అంతర్గతంగా ట్రీ-షేక్ చేయదగినవి, ఎందుకంటే అవి కంపైల్-టైమ్ మాత్రమే.
• కాన్స్ట్ అసర్షన్స్: అవి రన్‌టైమ్ ఆబ్జెక్ట్‌ను సృష్టించినప్పటికీ, ఆధునిక బండలర్‌లు టైప్‌స్క్రిప్ట్ యొక్క జనరేట్ చేయబడిన ఎన్యుమ్ ఆబ్జెక్ట్‌లతో పోలిస్తే ఈ ఆబ్జెక్ట్ యొక్క ఉపయోగించని ప్రాపర్టీలను మరింత సమర్థవంతంగా ట్రీ-షేక్ చేయగలవు. అయితే, మొత్తం ఆబ్జెక్ట్ దిగుమతి చేయబడి మరియు సూచించబడితే, అది చేర్చబడే అవకాశం ఉంది. జాగ్రత్తగా మాడ్యూల్ డిజైన్ సహాయపడుతుంది.

ఉత్తమ పద్ధతులు మరియు హైబ్రిడ్ విధానాలు

ఇది ఎల్లప్పుడూ "ఇది/లేదా" పరిస్థితి కాదు. తరచుగా, ఉత్తమ పరిష్కారం హైబ్రిడ్ విధానాన్ని కలిగి ఉంటుంది, ముఖ్యంగా పెద్ద, అంతర్జాతీయీకరించబడిన అప్లికేషన్‌లలో:

• సాధారణ, పూర్తిగా అంతర్గత ఫ్లాగ్‌లు లేదా ఐడెంటిఫైయర్‌ల కోసం, వాటిని ఎప్పుడూ ఇటరేట్ చేయాల్సిన అవసరం లేని లేదా అనుబంధిత డేటాను కలిగి ఉండని వాటి కోసం, యూనియన్ టైప్‌లు సాధారణంగా అత్యంత పనితీరు గల మరియు శుభ్రమైన ఎంపిక.
• ఇటరేట్ చేయాల్సిన, UIలలో ప్రదర్శించాల్సిన లేదా రిచ్ అనుబంధిత మెటాడేటాను (లేబుల్‌లు, ఐకాన్‌లు లేదా అనుమతులు వంటివి) కలిగి ఉన్న స్థిరాంక సమితుల కోసం, కాన్స్ట్ అసర్షన్స్ ప్యాటర్న్ ఉన్నతమైనది.
• రీడబిలిటీ మరియు స్థానికీకరణ కోసం కలపడం: అనేక బృందాలు అంతర్గత ఐడెంటిఫైయర్‌ల కోసం as constను ఉపయోగిస్తాయి మరియు తరువాత ప్రత్యేక అంతర్జాతీయీకరణ (i18n) సిస్టమ్ నుండి స్థానికీకరించబడిన డిస్‌ప్లే లేబుల్‌లను పొందుతాయి.

            // src/constants/order-status.ts
const OrderStatuses = {
  PENDING: "PENDING",
  PROCESSING: "PROCESSING",
  SHIPPED: "SHIPPED",
  DELIVERED: "DELIVERED",
  CANCELLED: "CANCELLED",
} as const;

type OrderStatus = typeof OrderStatuses[keyof typeof OrderStatuses];

export { OrderStatuses, type OrderStatus };

// src/i18n/en.json
{
  "orderStatus": {
    "PENDING": "Pending Confirmation",
    "PROCESSING": "Processing Order",
    "SHIPPED": "Shipped",
    "DELIVERED": "Delivered",
    "CANCELLED": "Cancelled"
  }
}

// src/i18n/locales/es.json
{
  "productCategories": {
    "ELECTRONICS": "Electrónica",
    "APPAREL": "Ropa y Accesorios",
    "HOME_GOODS": "Artículos para el hogar",
    "BOOKS": "Libros"
  }
}

// src/components/ProductCategorySelector.tsx
import { ProductCategories, type ProductCategory } from "../features/product/constants";
import { useTranslation } from "react-i18next"; // Example i18n library

interface OrderStatusDisplayProps {
  status: OrderStatus;
}

function OrderStatusDisplay({ status }: OrderStatusDisplayProps) {
  const { t } = useTranslation();
  const displayLabel = t(`orderStatus.${status}`);
  return <span>Status: {displayLabel}</span>;
}

// Usage:
// <OrderStatusDisplay status={OrderStatuses.DELIVERED} />

            

              
                Copy
              
            
          

ఈ ఆందోళనల విభజన స్కేలబుల్, గ్లోబల్ అప్లికేషన్‌ల కోసం చాలా ముఖ్యమైనది. టైప్‌స్క్రిప్ట్ టైప్‌లు మీరు ఎల్లప్పుడూ చెల్లుబాటు అయ్యే కీలను ఉపయోగిస్తున్నారని నిర్ధారిస్తాయి మరియు i18n సిస్టమ్ వినియోగదారు స్థానికత ఆధారంగా ప్రెజెంటేషన్ లేయర్‌ను నిర్వహిస్తుంది. ఇది మీ కోర్ అప్లికేషన్ లాజిక్‌లో భాషా-ఆధారిత స్ట్రింగ్‌లను నేరుగా పొందుపరచడాన్ని నివారిస్తుంది, ఇది అంతర్జాతీయ బృందాలకు ఒక సాధారణ వ్యతిరేక-నమూనా.

ముగింపు: మీ టైప్‌స్క్రిప్ట్ డిజైన్ ఎంపికలకు సాధికారత కల్పించడం

టైప్‌స్క్రిప్ట్ ప్రపంచవ్యాప్తంగా డెవలపర్‌లను మరింత పటిష్టమైన మరియు స్కేలబుల్ అప్లికేషన్‌లను రూపొందించడానికి నిరంతరం అభివృద్ధి చెందుతున్న మరియు అధికారం కల్పిస్తున్నందున, దాని సూక్ష్మ లక్షణాలు మరియు ప్రత్యామ్నాయాలను అర్థం చేసుకోవడం మరింత ముఖ్యమైనదిగా మారుతుంది. టైప్‌స్క్రిప్ట్ యొక్క enum కీవర్డ్ పేరున్న స్థిరాంకాలను నిర్వచించడానికి అనుకూలమైన మార్గాన్ని అందిస్తున్నప్పటికీ, దాని రన్‌టైమ్ ఫుట్‌ప్రింట్, ట్రీ-షేకింగ్ పరిమితులు మరియు రివర్స్ మ్యాపింగ్ సంక్లిష్టతలు తరచుగా ఆధునిక ప్రత్యామ్నాయాలను పనితీరు-సున్నితమైన లేదా పెద్ద-స్థాయి ప్రాజెక్ట్‌లకు మరింత ఆకర్షణీయంగా మారుస్తాయి.

స్ట్రింగ్/న్యూమరిక్ లిటరల్స్‌తో యూనియన్ టైప్‌లు అతి తేలికైన మరియు అత్యంత కంపైల్-టైమ్-సెంట్రిక్ పరిష్కారంగా నిలుస్తాయి. అవి రన్‌టైమ్‌లో ఎటువంటి జావాస్క్రిప్ట్‌ను ఉత్పత్తి చేయకుండా రాజీలేని టైప్ సేఫ్టీని అందిస్తాయి, కనిష్ట బండిల్ పరిమాణం మరియు గరిష్ట ట్రీ-షేకింగ్ ప్రాధాన్యతలుగా ఉన్న దృశ్యాలకు వాటిని ఆదర్శంగా మారుస్తాయి మరియు రన్‌టైమ్ ఎన్యూమరేషన్ ఆందోళన కాదు.

మరోవైపు, కాన్స్ట్ అసర్షన్స్ (as const)ను typeof మరియు keyofతో కలపడం అత్యంత సౌకర్యవంతమైన మరియు శక్తివంతమైన నమూనాని అందిస్తుంది. అవి మీ స్థిరాంకాల కోసం ఒకే సత్యాన్ని, బలమైన కంపైల్-టైమ్ టైప్ సేఫ్టీని మరియు రన్‌టైమ్‌లో విలువలపై ఇటరేట్ చేసే కీలక సామర్థ్యాన్ని అందిస్తాయి. ఈ విధానం మీ స్థిరాంకాలతో అదనపు డేటాను అనుబంధించాల్సిన, డైనమిక్ UIలను నింపాల్సిన లేదా అంతర్జాతీయీకరణ సిస్టమ్‌లతో సజావుగా విలీనం చేయాల్సిన పరిస్థితులకు ప్రత్యేకంగా సరిపోతుంది.

రన్‌టైమ్ ఫుట్‌ప్రింట్, ఇటరేషన్ అవసరాలు మరియు అనుబంధిత డేటా యొక్క సంక్లిష్టత - ఈ నష్టాలను జాగ్రత్తగా పరిగణించడం ద్వారా, మీరు పరిశుభ్రమైన, మరింత సమర్థవంతమైన మరియు మరింత నిర్వహించదగిన టైప్‌స్క్రిప్ట్ కోడ్‌కు దారితీసే సమాచార నిర్ణయాలు తీసుకోవచ్చు. ఈ ప్రత్యామ్నాయాలను స్వీకరించడం అనేది కేవలం "ఆధునిక" టైప్‌స్క్రిప్ట్‌ను వ్రాయడం మాత్రమే కాదు; ఇది మీ అప్లికేషన్ యొక్క పనితీరు, డెవలపర్ అనుభవం మరియు ప్రపంచ ప్రేక్షకుల కోసం దీర్ఘకాలిక స్థిరత్వాన్ని పెంచే ఉద్దేశపూర్వక నిర్మాణ ఎంపికలు చేయడం గురించి.

మెరుగైన ప్రత్యామ్నాయాలు ఉన్నప్పుడు డిఫాల్ట్ ఎన్యుమ్ దాటి, సరైన పనికి సరైన సాధనాన్ని ఎంచుకోవడం ద్వారా మీ టైప్‌స్క్రిప్ట్ అభివృద్ధికి అధికారం కల్పించండి.